﻿using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.SqlTypes;
using System.Data.SqlClient;
using System.Reflection;

using Noris.Schedule.Support;
using Noris.Schedule.Support.Sql;
using Noris.Schedule.Support.Data;

namespace Noris.Schedule.Planning.DataFace
{
	// UPOZORNĚNÍ: z důvodu budoucího rozšiřování funkcionality je ABSOLUTNĚ NEVHODNÉ měnit něco v těchto třídách.
	//    Po případném upgrade generátoru dataface (Aps.Data.TableCodeGeneratorCls) může nastat potřeba tyto třídy vygenerovat znovu.
	//    Pak by ruční změny v těchto třídách přišly vniveč.
	// DŮVODEM je časová optimalizace těchto tříd, která vede k nevhodnosti provádět datové práci genericky (Reflection).
	//    Případné další změny v generátoru DataFace vedou k nutnosti PŘEPSAT a ZNOVU VYGENEROVAT kódy jednotlivých tříd.
	// ŘEŠENÍ je jednoduché: veškeré úpravy třídy je možno provádět na zděděném potomkovi, no ne?
	// ------------------------------------------------------------------------------------------
	// Tento soubor obsahuje deklarace DataFaces, které kopírují struktury dat v Noris třídách do .NET tříd.
	// Jednotlivé třídy popisují data typicky jedné tabulky (ale mohou popisovat i data kombinovaná ze selectů).
	// Deklarace tříd generuje okno WinApsClientDaj.Forms.RecordCreateForm,
	//   používá generátor Aps.Data.TableCodeGeneratorCls
	#region CLASS ResourcesCalendarCls : Třída odvozená z tabulky lcs.resources_calendar
	/// <summary>
	/// ResourcesCalendarCls : Data z Master tabulky třídy 1196: Kalendář zdrojů (ResourcesCalendarInst), Subjektová
	/// Data načtena z tabulky lcs.resources_calendar
	/// </summary>
	public partial class ResourcesCalendarCls : RecordCls, Noris.Schedule.Support.Sql.IDbRecord
	{
		#region KONSTRUKCE A PUBLIC OVERRIDE PROPERTY
		/// <summary>
		/// Implicitní konstruktor, zajistí číslování záznamů do jednotné Temporary řady
		/// </summary>
		public ResourcesCalendarCls()
			: base()
		{ }
		/// <summary>
		/// Explicitní konstruktor, dovolí zvolit, zda se pro tento záznam bude generovat Temporary ID
		/// </summary>
		/// <param name="createTemporaryId">true pokud se pro záznam má vytvořit Temporary ID.
		/// Default (false) = nevytvoří se, bude mít RecordNumber = 0.</param>
		public ResourcesCalendarCls(bool createTemporaryId)
			: base(createTemporaryId)
		{ }
		/// <summary>
		/// Číslo třídy: 1196
		/// </summary>
		public override int ClassNumber { get { return ClassNr; } }
		/// <summary>Číslo třídy</summary>
		public const int ClassNr = 1196;
		/// <summary>Číslo záznamu = cislo_subjektu</summary>
		public override int RecordNumber { get { return base._cislo_subjektu; } }
		/// <summary>IDbRecord.RecordNumber : musí konkrétně implementovat set, protože DbLayer po uložení nového záznamu (kde RecordNumber == 0) do něj vloží přidělený klíč</summary>
		int IDbRecord.RecordNumber
		{
			get { return this.RecordNumber; }
			set { base._cislo_subjektu = value; }
		}
		#endregion
		#region PUBLIC DATA PROPERTY
		///<summary><para>Atribut: Uplatnit svátky [typ_ano_ne]</para><para>Db: lcs.resources_calendar.apply_holiday (char (1) not null)</para></summary>
		public string ApplyHoliday { get { return _apply_holiday; } }
		///<summary><para>Vztah 9168: Svátky (zprava: Kalendář zdrojů)</para><para>Db: lcs.resources_calendar.holiday (int null)</para></summary>
		public SqlInt32 Holiday { get { return _holiday; } }
		///<summary><para>Atribut: Povinnost směny [typ_ano_ne]</para><para>Db: lcs.resources_calendar.shift_liable (char (1) not null)</para></summary>
		public string ShiftLiable { get { return _shift_liable; } }
		#endregion
		#region PROTECTED DATA FIELDS
		protected string _apply_holiday;
		protected SqlInt32 _holiday;
		protected string _shift_liable;
		#endregion
		#region FILL FROM READER
		/// <summary>
		/// Virtuální metoda, která umožňuje potomkům provádět typovou a rychlou konverzi dat proudících z databáze přes DataReader 
		/// přímo do objektu této třídy, bez použití generické metody FieldInfo.SetValue (která je poněkud pomalá).
		/// Tato metoda v této třídě tedy má naplnit každou svoji instanční proměnnou (field) hodnotou z předaného SqlDataReaderu.
		/// Pro snadné načtení dat je předán objekt mapper, který nabízí svou generickou metodu FillDataIntoField«int»(string dbColumnName, SqlDataReader reader).
		/// Tato metoda vrátí načtená data (typovaná jako objekt).
		/// Čtení touto metodou je cca 6x rychlejší než čtení generickou metodou.
		/// Metoda má vracet true, pokud převzala všechna data. 
		/// Je nanejvýše účelné, aby tak provedla, protože pokud vrátí false, pak se po jejím skončení provede generické ukládání dat (což je 6x pomalejší).
		/// </summary>
		/// <param name='reader'>Vstupní DataReader</param>
		/// <param name='map'>Mapování dat z readeru na fields tohoto objektu</param>
		/// <returns>true = data byla převzata / false = data nepřevzata</returns>
		public override bool FillFromReader(SqlDataReader reader, FieldMapperLoad map)
		{
			base.FillFromReader(reader, map);                 // naplní systémové atributy, vrací false
			_apply_holiday = (string)map.FillDataIntoField<string>("apply_holiday", reader);
			_holiday = (SqlInt32)map.FillDataIntoField<SqlInt32>("holiday", reader);
			_shift_liable = (string)map.FillDataIntoField<string>("shift_liable", reader);
			return true;
		}
		#endregion
		#region STATIC GENERÁTORY SELECTU
		/// <summary>
		/// SQL SELECT pro načtení columnů, odpovídajících této struktuře. Pozor: neobsahuje filtr ani order.
		/// </summary>
		public static new string SqlSelect { get { return "SELECT cislo_subjektu, reference_subjektu, nazev_subjektu, cislo_poradace, apply_holiday, holiday, shift_liable FROM lcs.resources_calendar"; } }
		/// <summary>
		/// Jméno sloupce, který obsahuje klíč záznamu, určeno pro filtry.
		/// </summary>
		public static new string SqlRecord { get { return "cislo_subjektu"; } }
		/// <summary>
		/// Generátor SELECTU pro načítání do CACHE.
		/// Vrátí SQL SELECT, který používá SysCache pro automatické načítání záznamů do cache.
		/// Vrácený select má tvar "SELECT * FROM tabulka [join lcs.subjekty] WHERE [master_tabulka.]key_column", cache si doplní číslo[a] záznamů sama.
		/// </summary>
		/// <returns>Vrátí SQL SELECT, který používá SysCache pro automatické načítání záznamů do cache.</returns>
		public override string GetCacheSelect()
		{
			return SqlSelect + " WHERE " + SqlRecord;
		}
		#endregion
	}
	#endregion
	#region CLASS ResourcesCalendarDataCls : Třída odvozená z tabulky lcs.resources_calendar_data  --  POZOR : RecordNumber = _cislo_nonsubjektu
	/// <summary>
	/// ResourcesCalendarDataCls : Data z Master tabulky třídy 1207: Položky kalendáře zdrojů (ResourcesCalendarDataInst), Nonsubjektová
	/// Data načtena z tabulky lcs.resources_calendar_data
	/// </summary>
	public partial class ResourcesCalendarDataCls : RecordCls, Noris.Schedule.Support.Sql.IDbRecord
	{
		#region KONSTRUKTORY
		/// <summary>
		/// Implicitní konstruktor, zajistí číslování záznamů do jednotné Temporary řady
		/// </summary>
		public ResourcesCalendarDataCls()
			: base()
		{ }
		/// <summary>
		/// Konstruktor s načítáním dat z databáze
		/// </summary>
		/// <param name="recordNumber">Číslo záznamu, který je třeba načíst</param>
		public ResourcesCalendarDataCls(int recordNumber)
			: base(recordNumber)
		{ }
		/// <summary>
		/// Explicitní konstruktor, dovolí zvolit, zda se pro tento záznam bude generovat Temporary ID
		/// </summary>
		/// <param name="createTemporaryId">true pokud se pro záznam má vytvořit Temporary ID.
		/// Default (false) = nevytvoří se, bude mít RecordNumber = 0.</param>
		public ResourcesCalendarDataCls(bool createTemporaryId)
			: base(createTemporaryId)
		{ }
		#endregion
		#region PUBLIC OVERRIDE PROPERTY
		/// <summary>
		/// Číslo třídy: 1207
		/// </summary>
		public override int ClassNumber { get { return ClassNr; } }
		/// <summary>Číslo třídy</summary>
		public const int ClassNr = 1207;
		/// <summary>Číslo záznamu = cislo_nonsubjektu</summary>
		public override int RecordNumber { get { return base._cislo_nonsubjektu; } }
		/// <summary>IDbRecord.RecordNumber : musí konkrétně implementovat set, protože DbLayer po uložení nového záznamu (kde RecordNumber == 0) do něj vloží přidělený klíč</summary>
		int IDbRecord.RecordNumber
		{
			get { return this.RecordNumber; }
			set { base._cislo_nonsubjektu = value; }
		}
		#endregion
		#region PUBLIC DATA PROPERTY
		///<summary><para>Atribut: Konec úseku</para><para>Db: lcs.resources_calendar_data.stop_interval (smalldatetime not null)</para></summary>
		public DateTime StopInterval { get { return _stop_interval; } }
		///<summary><para>Atribut: Začátek úseku</para><para>Db: lcs.resources_calendar_data.start_interval (smalldatetime not null)</para></summary>
		public DateTime StartInterval { get { return _start_interval; } }
		///<summary><para>Atribut: Využitelná kapacita</para><para>Db: lcs.resources_calendar_data.effective_capacity (numeric_19_6 not null)</para></summary>
		public decimal EffectiveCapacity { get { return _effective_capacity; } }
		///<summary><para>Vztah 9091: Subjekt (zprava: Položky kalendáře)</para><para>Db: lcs.resources_calendar_data.subject (int null)</para></summary>
		public SqlInt32 Subject { get { return _subject; } }
		///<summary><para>Vztah 9089: Definice kalendáře zdrojů (zprava: Definice Kalendáře)</para><para>Db: lcs.resources_calendar_data.resources_calendar_def (int null)</para></summary>
		public SqlInt32 ResourcesCalendarDef { get { return _resources_calendar_def; } }
		///<summary><para>Vztah 9090: Kalendář zdrojů (zprava: Položky kalendáře)</para><para>Db: lcs.resources_calendar_data.resources_calendar (int null)</para></summary>
		public SqlInt32 ResourcesCalendar { get { return _resources_calendar; } }
		///<summary><para>Vztah 100491: Směna (zprava: Položky kalendáře zdrojů)</para><para>Db: lcs.resources_calendar_data.workshift (int null)</para></summary>
		public SqlInt32 Workshift { get { return _workshift; } }
		///<summary><para>Vztah 100492: Verze kapacitního plánu (zprava: Položka kalendáře zdrojů)</para><para>Db: lcs.resources_calendar_data.plan_c_version (int null)</para></summary>
		public SqlInt32 PlanCVersion { get { return _plan_c_version; } }
		///<summary><para>Atribut: Počet jednotek</para><para>Db: lcs.resources_calendar_data.pocet_jednotek (int null)</para></summary>
		public SqlInt32 PocetJednotek { get { return _pocet_jednotek; } }
		#endregion
		#region PROTECTED DATA FIELDS
		protected DateTime _stop_interval;
		protected DateTime _start_interval;
		protected decimal _effective_capacity;
		protected SqlInt32 _subject;
		protected SqlInt32 _resources_calendar_def;
		protected SqlInt32 _resources_calendar;
		protected SqlInt32 _workshift;
		protected SqlInt32 _plan_c_version;
		protected SqlInt32 _pocet_jednotek;
		#endregion
		#region FILL FROM READER
		/// <summary>
		/// Virtuální metoda, která umožňuje potomkům provádět typovou a rychlou konverzi dat proudících z databáze přes DataReader 
		/// přímo do objektu této třídy, bez použití generické metody FieldInfo.SetValue (která je poněkud pomalá).
		/// Tato metoda v této třídě tedy má naplnit každou svoji instanční proměnnou (field) hodnotou z předaného SqlDataReaderu.
		/// Pro snadné načtení dat je předán objekt mapper, který nabízí svou generickou metodu FillDataIntoField«int»(string dbColumnName, SqlDataReader reader).
		/// Tato metoda vrátí načtená data (typovaná jako objekt).
		/// Čtení touto metodou je cca 6x rychlejší než čtení generickou metodou.
		/// Metoda má vracet true, pokud převzala všechna data. 
		/// Je nanejvýše účelné, aby tak provedla, protože pokud vrátí false, pak se po jejím skončení provede generické ukládání dat (což je 6x pomalejší).
		/// </summary>
		/// <param name="reader">Vstupní DataReader</param>
		/// <param name="map">Mapování dat z readeru na fields tohoto objektu</param>
		/// <returns>true = data byla převzata / false = data nepřevzata</returns>
		public override bool FillFromReader(SqlDataReader reader, FieldMapperLoad map)
		{
			base.FillFromReader(reader, map);
			_stop_interval = (DateTime)map.FillDataIntoField<DateTime>("stop_interval", reader);
			_start_interval = (DateTime)map.FillDataIntoField<DateTime>("start_interval", reader);
			_effective_capacity = (decimal)map.FillDataIntoField<decimal>("effective_capacity", reader);
			_subject = (SqlInt32)map.FillDataIntoField<SqlInt32>("subject", reader);
			_resources_calendar_def = (SqlInt32)map.FillDataIntoField<SqlInt32>("resources_calendar_def", reader);
			_resources_calendar = (SqlInt32)map.FillDataIntoField<SqlInt32>("resources_calendar", reader);
			_workshift = (SqlInt32)map.FillDataIntoField<SqlInt32>("workshift", reader);
			_plan_c_version = (SqlInt32)map.FillDataIntoField<SqlInt32>("plan_c_version", reader);
			_pocet_jednotek = (SqlInt32)map.FillDataIntoField<SqlInt32>("pocet_jednotek", reader);
			return true;
		}
		#endregion
		#region STATIC GENERÁTORY SELECTU
		/// <summary>
		/// SQL SELECT pro načtení columnů, odpovídajících této struktuře. Pozor: neobsahuje filtr ani order.
		/// </summary>
		public static new string SqlSelect { get { return "SELECT * FROM lcs.resources_calendar_data"; } }
		/// <summary>
		/// Jméno sloupce, který obsahuje klíč záznamu, určeno pro filtry.
		/// </summary>
		public static new string SqlRecord { get { return "lcs.resources_calendar_data.cislo_nonsubjektu"; } }
		/// <summary>
		/// Generátor SELECTU pro načítání do CACHE.
		/// Vrátí SQL SELECT, který používá SysCache pro automatické načítání záznamů do cache.
		/// Vrácený select má tvar "SELECT * FROM tabulka [join lcs.subjekty] WHERE [master_tabulka.]key_column", cache si doplní číslo[a] záznamů sama.
		/// </summary>
		/// <returns>Vrátí SQL SELECT, který používá SysCache pro automatické načítání záznamů do cache.</returns>
		public override string GetCacheSelect()
		{
			return SqlSelect + " WHERE " + SqlRecord;
		}
		#endregion
	}
	#endregion
	#region CLASS HolidayItmCls : Třída odvozená z tabulky lcs.holiday_itm                         --  POZOR : RecordNumber = _cislo_objektu
	/// <summary>
	/// HolidayItmCls : Data z Entries tabulky třídy 1217: Svátky (HolidayInst), Subjektová
	/// Data načtena z tabulky lcs.holiday_itm
	/// </summary>
	public partial class HolidayItmCls : RecordCls, Noris.Schedule.Support.Sql.IDbRecord
	{
		#region KONSTRUKCE A PUBLIC OVERRIDE PROPERTY
		/// <summary>
		/// Implicitní konstruktor, zajistí číslování záznamů do jednotné Temporary řady
		/// </summary>
		public HolidayItmCls()
			: base()
		{ }
		/// <summary>
		/// Explicitní konstruktor, dovolí zvolit, zda se pro tento záznam bude generovat Temporary ID
		/// </summary>
		/// <param name="createTemporaryId">true pokud se pro záznam má vytvořit Temporary ID.
		/// Default (false) = nevytvoří se, bude mít RecordNumber = 0.</param>
		public HolidayItmCls(bool createTemporaryId)
			: base(createTemporaryId)
		{ }
		/// <summary>
		/// Číslo třídy: -1217
		/// </summary>
		public override int ClassNumber { get { return ClassNr; } }
		/// <summary>Číslo třídy</summary>
		public const int ClassNr = -1217;
		/// <summary>Číslo záznamu = cislo_objektu</summary>
		public override int RecordNumber { get { return base._cislo_objektu; } }
		/// <summary>IDbRecord.RecordNumber : musí konkrétně implementovat set, protože DbLayer po uložení nového záznamu (kde RecordNumber == 0) do něj vloží přidělený klíč</summary>
		int IDbRecord.RecordNumber
		{
			get { return this.RecordNumber; }
			set { base._cislo_objektu = value; }
		}
		#endregion
		#region PUBLIC DATA PROPERTY
		///<summary><para>Atribut: Číslo řádky</para><para>Db: lcs.holiday_itm.cislo_radky (smallint not null)</para></summary>
		public Int32 CisloRadky { get { return _cislo_radky; } }
		///<summary><para>Atribut: Datum svátku</para><para>Db: lcs.holiday_itm.date_holiday (smalldatetime not null)</para></summary>
		public DateTime DateHoliday { get { return _date_holiday; } }
		///<summary><para>Atribut: Pevné datum [typ_ano_ne]</para><para>Db: lcs.holiday_itm.fixed_date (char (1) not null)</para></summary>
		public string FixedDate { get { return _fixed_date; } }
		#endregion
		#region PROTECTED DATA FIELDS
		protected Int32 _cislo_radky;
		protected DateTime _date_holiday;
		protected string _fixed_date;
		#endregion
		#region FILL FROM READER
		/// <summary>
		/// Virtuální metoda, která umožňuje potomkům provádět typovou a rychlou konverzi dat proudících z databáze přes DataReader 
		/// přímo do objektu této třídy, bez použití generické metody FieldInfo.SetValue (která je poněkud pomalá).
		/// Tato metoda v této třídě tedy má naplnit každou svoji instanční proměnnou (field) hodnotou z předaného SqlDataReaderu.
		/// Pro snadné načtení dat je předán objekt mapper, který nabízí svou generickou metodu FillDataIntoField«int»(string dbColumnName, SqlDataReader reader).
		/// Tato metoda vrátí načtená data (typovaná jako objekt).
		/// Čtení touto metodou je cca 6x rychlejší než čtení generickou metodou.
		/// Metoda má vracet true, pokud převzala všechna data. 
		/// Je nanejvýše účelné, aby tak provedla, protože pokud vrátí false, pak se po jejím skončení provede generické ukládání dat (což je 6x pomalejší).
		/// </summary>
		/// <param name='reader'>Vstupní DataReader</param>
		/// <param name='map'>Mapování dat z readeru na fields tohoto objektu</param>
		/// <returns>true = data byla převzata / false = data nepřevzata</returns>
		public override bool FillFromReader(SqlDataReader reader, FieldMapperLoad map)
		{
			base.FillFromReader(reader, map);                 // naplní systémové atributy, vrací false
			_cislo_radky = (Int32)map.FillDataIntoField<Int32>("cislo_radky", reader);
			_date_holiday = (DateTime)map.FillDataIntoField<DateTime>("date_holiday", reader);
			_fixed_date = (string)map.FillDataIntoField<string>("fixed_date", reader);
			return true;
		}
		#endregion
		#region STATIC GENERÁTORY SELECTU
		/// <summary>
		/// SQL SELECT pro načtení columnů, odpovídajících této struktuře. Pozor: neobsahuje filtr ani order.
		/// </summary>
		public static new string SqlSelect { get { return "SELECT cislo_subjektu, cislo_objektu, cislo_radky, date_holiday, fixed_date FROM lcs.holiday_itm"; } }
		/// <summary>
		/// Jméno sloupce, který obsahuje klíč záznamu, určeno pro filtry.
		/// </summary>
		public static new string SqlRecord { get { return "cislo_objektu"; } }
		/// <summary>
		/// Generátor SELECTU pro načítání do CACHE.
		/// Vrátí SQL SELECT, který používá SysCache pro automatické načítání záznamů do cache.
		/// Vrácený select má tvar "SELECT * FROM tabulka [join lcs.subjekty] WHERE [master_tabulka.]key_column", cache si doplní číslo[a] záznamů sama.
		/// </summary>
		/// <returns>Vrátí SQL SELECT, který používá SysCache pro automatické načítání záznamů do cache.</returns>
		public override string GetCacheSelect()
		{
			return SqlSelect + " WHERE " + SqlRecord;
		}
		#endregion
	}
	#endregion
	#region CLASS PlanUnitCCls : Třída odvozená z tabulky lcs.plan_unit_c
	/// <summary>
	/// PlanUnitCCls : Data z Master tabulky třídy 1364: Kapacitní plánovací jednotka (PlanUnitCInst), Subjektová
	/// Data načtena z tabulky lcs.plan_unit_c
	/// </summary>
	public partial class PlanUnitCCls : RecordCls, Noris.Schedule.Support.Sql.IDbRecord
	{
		#region KONSTRUKCE A PUBLIC OVERRIDE PROPERTY
		/// <summary>
		/// Implicitní konstruktor, zajistí číslování záznamů do jednotné Temporary řady
		/// </summary>
		public PlanUnitCCls()
			: base()
		{ }
		/// <summary>
		/// Explicitní konstruktor, dovolí zvolit, zda se pro tento záznam bude generovat Temporary ID
		/// </summary>
		/// <param name="createTemporaryId">true pokud se pro záznam má vytvořit Temporary ID.
		/// Default (false) = nevytvoří se, bude mít RecordNumber = 0.</param>
		public PlanUnitCCls(bool createTemporaryId)
			: base(createTemporaryId)
		{ }
		/// <summary>
		/// Číslo třídy: 1364
		/// </summary>
		public override int ClassNumber { get { return ClassNr; } }
		/// <summary>Číslo třídy: 1364</summary>
		public const int ClassNr = 1364;
		/// <summary>Číslo záznamu = cislo_subjektu</summary>
		public override int RecordNumber { get { return base._cislo_subjektu; } }
		/// <summary>IDbRecord.RecordNumber : musí konkrétně implementovat set, protože DbLayer po uložení nového záznamu (kde RecordNumber == 0) do něj vloží přidělený klíč</summary>
		int IDbRecord.RecordNumber
		{
			get { return this.RecordNumber; }
			set { base._cislo_subjektu = value; }
		}
		#endregion
		#region PUBLIC DATA PROPERTY
		///<summary><para>Atribut: Plánovat [typ_ano_ne]</para><para>Db: lcs.plan_unit_c.plan_me (char (1) not null)</para></summary>
		public string PlanMe { get { return _plan_me; } }
		///<summary><para>Atribut: Použít Tac [typ_ano_ne]</para><para>Db: lcs.plan_unit_c.use_tac (char (1) not null)</para></summary>
		public string UseTac { get { return _use_tac; } }
		///<summary><para>Atribut: Použít Tbc [typ_ano_ne]</para><para>Db: lcs.plan_unit_c.use_tbc (char (1) not null)</para></summary>
		public string UseTbc { get { return _use_tbc; } }
		///<summary><para>Atribut: Použít Tec [typ_ano_ne]</para><para>Db: lcs.plan_unit_c.use_tec (char (1) not null)</para></summary>
		public string UseTec { get { return _use_tec; } }
		///<summary><para>Atribut: Použít transportní čas [typ_ano_ne]</para><para>Db: lcs.plan_unit_c.use_move_time (char (1) not null)</para></summary>
		public string UseMoveTime { get { return _use_move_time; } }
		///<summary><para>Atribut: Způsob plánování [mfr_limited_c_type]</para><para>Db: lcs.plan_unit_c.limited_c_type (char (1) not null)</para></summary>
		public string LimitedCType { get { return _limited_c_type; } }
		///<summary><para>Atribut: Vytížení kapacity [mfr_percent]</para><para>Db: lcs.plan_unit_c.capacity_utilization (decimal (5) not null)</para></summary>
		public decimal CapacityUtilization { get { return _capacity_utilization; } }
		///<summary><para>Atribut: Počet jednotek [editgeneral]</para><para>Db: lcs.plan_unit_c.machines_cnt (int not null)</para></summary>
		public int MachinesCnt { get { return _machines_cnt; } }
		///<summary><para>Vztah 100345: Kapacitní zdroj (zprava: Kapacitní PJ)</para><para>Db: lcs.plan_unit_c.c_source (int null)</para></summary>
		public SqlInt32 CSource { get { return _c_source; } }
		///<summary><para>Vztah 100537: Kalendář zdrojů (zprava: Kapacitní Plánovací jednotka)</para><para>Db: lcs.plan_unit_c.resources_calendar (int not null)</para></summary>
		public int ResourcesCalendar { get { return _resources_calendar; } }
		#endregion
		#region PROTECTED DATA FIELDS
		protected string _plan_me;
		protected string _use_tac;
		protected string _use_tbc;
		protected string _use_tec;
		protected string _use_move_time;
		protected string _limited_c_type;
		protected decimal _capacity_utilization;
		protected int _machines_cnt;
		protected SqlInt32 _c_source;
		protected int _resources_calendar;
		#endregion
		#region FILL FROM READER
		/// <summary>
		/// Virtuální metoda, která umožňuje potomkům provádět typovou a rychlou konverzi dat proudících z databáze přes DataReader 
		/// přímo do objektu této třídy, bez použití generické metody FieldInfo.SetValue (která je poněkud pomalá).
		/// Tato metoda v této třídě tedy má naplnit každou svoji instanční proměnnou (field) hodnotou z předaného SqlDataReaderu.
		/// Pro snadné načtení dat je předán objekt mapper, který nabízí svou generickou metodu FillDataIntoField«int»(string dbColumnName, SqlDataReader reader).
		/// Tato metoda vrátí načtená data (typovaná jako objekt).
		/// Čtení touto metodou je cca 6x rychlejší než čtení generickou metodou.
		/// Metoda má vracet true, pokud převzala všechna data. 
		/// Je nanejvýše účelné, aby tak provedla, protože pokud vrátí false, pak se po jejím skončení provede generické ukládání dat (což je 6x pomalejší).
		/// </summary>
		/// <param name='reader'>Vstupní DataReader</param>
		/// <param name='map'>Mapování dat z readeru na fields tohoto objektu</param>
		/// <returns>true = data byla převzata / false = data nepřevzata</returns>
		public override bool FillFromReader(SqlDataReader reader, FieldMapperLoad map)
		{
			base.FillFromReader(reader, map);                 // naplní systémové atributy, vrací false
			_plan_me = (string)map.FillDataIntoField<string>("plan_me", reader);
			_use_tac = (string)map.FillDataIntoField<string>("use_tac", reader);
			_use_tbc = (string)map.FillDataIntoField<string>("use_tbc", reader);
			_use_tec = (string)map.FillDataIntoField<string>("use_tec", reader);
			_use_move_time = (string)map.FillDataIntoField<string>("use_move_time", reader);
			_limited_c_type = (string)map.FillDataIntoField<string>("limited_c_type", reader);
			_capacity_utilization = (decimal)map.FillDataIntoField<decimal>("capacity_utilization", reader);
			_machines_cnt = (int)map.FillDataIntoField<int>("machines_cnt", reader);
			_c_source = (SqlInt32)map.FillDataIntoField<SqlInt32>("c_source", reader);
			_resources_calendar = (int)map.FillDataIntoField<int>("resources_calendar", reader);
			return true;
		}
		#endregion
		#region STATIC GENERÁTORY SELECTU
		/// <summary>
		/// SQL SELECT pro načtení columnů, odpovídajících této struktuře. Pozor: neobsahuje filtr ani order.
		/// </summary>
		public static new string SqlSelect { get { return "SELECT * FROM lcs.plan_unit_c"; } }
		/// <summary>
		/// Jméno sloupce, který obsahuje klíč záznamu, určeno pro filtry.
		/// </summary>
		public static new string SqlRecord { get { return "cislo_subjektu"; } }
		/// <summary>
		/// Generátor SELECTU pro načítání do CACHE.
		/// Vrátí SQL SELECT, který používá SysCache pro automatické načítání záznamů do cache.
		/// Vrácený select má tvar "SELECT * FROM tabulka [join lcs.subjekty] WHERE [master_tabulka.]key_column", cache si doplní číslo[a] záznamů sama.
		/// </summary>
		/// <returns>Vrátí SQL SELECT, který používá SysCache pro automatické načítání záznamů do cache.</returns>
		public override string GetCacheSelect()
		{
			return SqlSelect + " WHERE " + SqlRecord;
		}
		#endregion
	}
	#endregion
	#region CLASS PlanUnitCClCls : Třída odvozená z tabulky lcs.plan_unit_c_cl
	/// <summary>
	/// PlanUnitCClCls : Data z Master tabulky třídy 1365: Stav kapacit (PlanUnitCClInst), Nonsubjektová
	/// Data načtena z tabulky lcs.plan_unit_c_cl
	/// </summary>
	public partial class PlanUnitCClCls : RecordCls, Noris.Schedule.Support.Sql.IDbRecord
	{
		#region KONSTRUKTORY
		/// <summary>
		/// Implicitní konstruktor, zajistí číslování záznamů do jednotné Temporary řady
		/// </summary>
		public PlanUnitCClCls()
			: base()
		{ }
		/// <summary>
		/// Konstruktor s načítáním dat z databáze
		/// </summary>
		/// <param name="recordNumber">Číslo záznamu, který je třeba načíst</param>
		public PlanUnitCClCls(int recordNumber)
			: base(recordNumber)
		{ }
		/// <summary>
		/// Explicitní konstruktor, dovolí zvolit, zda se pro tento záznam bude generovat Temporary ID
		/// </summary>
		/// <param name="createTemporaryId">true pokud se pro záznam má vytvořit Temporary ID.
		/// Default (false) = nevytvoří se, bude mít RecordNumber = 0.</param>
		public PlanUnitCClCls(bool createTemporaryId)
			: base(createTemporaryId)
		{ }
		#endregion
		#region PUBLIC OVERRIDE PROPERTY
		/// <summary>Číslo třídy (1365)</summary>
		public override int ClassNumber { get { return ClassNr; } }
		/// <summary>Číslo třídy (1365)</summary>
		public const int ClassNr = 1365;
		/// <summary>Číslo záznamu = cislo_nonsubjektu</summary>
		public override int RecordNumber { get { return base._cislo_nonsubjektu; } }
		/// <summary>IDbRecord.RecordNumber : musí konkrétně implementovat set, protože DbLayer po uložení nového záznamu (kde RecordNumber == 0) do něj vloží přidělený klíč</summary>
		int IDbRecord.RecordNumber
		{
			get { return this.RecordNumber; }
			set { base._cislo_nonsubjektu = value; }
		}
		#endregion
		#region PUBLIC DATA PROPERTY
		///<summary><para>Atribut: Plánovací perioda [mfr_puc_cycle] {"H"=Hodina; "D"=Den; "M"=Měsíc; "Y"=Rok; "C"=Kalendář; "W"=Týden}</para><para>Db: lcs.plan_unit_c_cl.c_cycle (char (1) not null)</para></summary>
		public string CCycle { get { return _c_cycle; } set { _c_cycle = value; } }
		///<summary><para>Atribut: Počátek časové periody [Datum_cas]</para><para>Db: lcs.plan_unit_c_cl.start_time (datetime not null)</para></summary>
		public DateTime StartTime { get { return _start_time; } set { _start_time = value; } }
		///<summary><para>Atribut: Konec časové kapacity [Datum_cas]</para><para>Db: lcs.plan_unit_c_cl.end_time (datetime not null)</para></summary>
		public DateTime EndTime { get { return _end_time; } set { _end_time = value; } }
		///<summary><para>Atribut: Dostupná kapacita [editnumeric_19_6]</para><para>Db: lcs.plan_unit_c_cl.capacity (numeric_19_6 not null)</para></summary>
		public decimal Capacity { get { return _capacity; } set { _capacity = value; } }
		///<summary><para>Atribut: Kapacita kat.skut. [editnumeric_19_6]</para><para>Db: lcs.plan_unit_c_cl.capacity_used (numeric_19_6 not null)</para></summary>
		public decimal CapacityUsed { get { return _capacity_used; } set { _capacity_used = value; } }
		///<summary><para>Vztah 100346: Kapacitní plánovací jednotka (zprava: Stav kapacit)</para><para>Db: lcs.plan_unit_c_cl.plan_unit_c (int not null)</para></summary>
		public int PlanUnitC { get { return _plan_unit_c; } set { _plan_unit_c = value; } }
		///<summary><para>Vztah 100561: Kapacitní verze plánu (zprava: Stav kapacit)</para><para>Db: lcs.plan_unit_c_cl.plan_c_version (int not null)</para></summary>
		public int PlanCVersion { get { return _plan_c_version; } set { _plan_c_version = value; } }
		///<summary><para>Atribut: Kapacita kat.simulace [editnumeric_19_6]</para><para>Db: lcs.plan_unit_c_cl.capacity_used_sim (numeric_19_6 not null)</para></summary>
		public decimal CapacityUsedSim { get { return _capacity_used_sim; } set { _capacity_used_sim = value; } }
		///<summary><para>Atribut: Kapacita kat.plán [editnumeric_19_6]</para><para>Db: lcs.plan_unit_c_cl.capacity_used_pl (numeric_19_6 not null)</para></summary>
		public decimal CapacityUsedPl { get { return _capacity_used_pl; } set { _capacity_used_pl = value; } }
		#endregion
		#region PROTECTED DATA FIELDS
		protected string _c_cycle;
		protected DateTime _start_time;
		protected DateTime _end_time;
		protected decimal _capacity;
		protected decimal _capacity_used;
		protected int _plan_unit_c;
		protected int _plan_c_version;
		protected decimal _capacity_used_sim;
		protected decimal _capacity_used_pl;
		#endregion
		#region FILL FROM READER
		/// <summary>
		/// Virtuální metoda, která umožňuje potomkům provádět typovou a rychlou konverzi dat proudících z databáze přes DataReader 
		/// přímo do objektu této třídy, bez použití generické metody FieldInfo.SetValue (která je poněkud pomalá).
		/// Tato metoda v této třídě tedy má naplnit každou svoji instanční proměnnou (field) hodnotou z předaného SqlDataReaderu.
		/// Pro snadné načtení dat je předán objekt mapper, který nabízí svou generickou metodu FillDataIntoField«int»(string dbColumnName, SqlDataReader reader).
		/// Tato metoda vrátí načtená data (typovaná jako objekt).
		/// Čtení touto metodou je cca 6x rychlejší než čtení generickou metodou.
		/// Metoda má vracet true, pokud převzala všechna data. 
		/// Je nanejvýše účelné, aby tak provedla, protože pokud vrátí false, pak se po jejím skončení provede generické ukládání dat (což je 6x pomalejší).
		/// </summary>
		/// <param name="reader">Vstupní DataReader</param>
		/// <param name="map">Mapování dat z readeru na fields tohoto objektu</param>
		/// <returns>true = data byla převzata / false = data nepřevzata</returns>
		public override bool FillFromReader(SqlDataReader reader, FieldMapperLoad map)
		{
			base.FillFromReader(reader, map);
			_c_cycle = (string)map.FillDataIntoField<string>("c_cycle", reader);
			_start_time = (DateTime)map.FillDataIntoField<DateTime>("start_time", reader);
			_end_time = (DateTime)map.FillDataIntoField<DateTime>("end_time", reader);
			_capacity = (decimal)map.FillDataIntoField<decimal>("capacity", reader);
			_capacity_used = (decimal)map.FillDataIntoField<decimal>("capacity_used", reader);
			_plan_unit_c = (int)map.FillDataIntoField<int>("plan_unit_c", reader);
			_plan_c_version = (int)map.FillDataIntoField<int>("plan_c_version", reader);
			_capacity_used_sim = (decimal)map.FillDataIntoField<decimal>("capacity_used_sim", reader);
			_capacity_used_pl = (decimal)map.FillDataIntoField<decimal>("capacity_used_pl", reader);
			return true;
		}
		#endregion
		#region SAVE RECORD
		/// <summary>
		/// Zajistí přípravu svých dat do podkladové vrstvy pro uložení do databáze.
		/// Subjektové třídy musí nejprve volat SubjectCls.PrepareSaveData(this, map);, 
		/// tím se uloží data do tabulky subjektů (a pro nové záznamy se vygeneruje číslo subjektu).
		/// Nonsubjektové třídy to volat nesmí.
		/// </summary>
		/// <param name="map"></param>
		/// <returns></returns>
		public override bool PrepareSaveData(FieldMapperSave map)
		{
			map.AddTable("lcs.plan_unit_c_cl", "cislo_nonsubjektu");
			map.AddColumn("c_cycle", this.CCycle);
			map.AddColumn("start_time", this.StartTime);
			map.AddColumn("end_time", this.EndTime);
			map.AddColumn("capacity", this.Capacity);
			map.AddColumn("capacity_used", this.CapacityUsed);
			map.AddColumn("plan_unit_c", this.PlanUnitC);
			map.AddColumn("plan_c_version", this.PlanCVersion);
			map.AddColumn("capacity_used_sim", this.CapacityUsedSim);
			map.AddColumn("capacity_used_pl", this.CapacityUsedPl);
			map.AddTableEnd();
			return true;
		}
		#endregion
		#region STATIC GENERÁTORY SELECTU
		/// <summary>
		/// SQL SELECT pro načtení columnů, odpovídajících této struktuře. Pozor: neobsahuje filtr ani order.
		/// </summary>
		public static new string SqlSelect { get { return @"SELECT * FROM lcs.plan_unit_c_cl"; } }
		/// <summary>
		/// Jméno sloupce, který obsahuje klíč záznamu, určeno pro filtry.
		/// </summary>
		public static new string SqlRecord { get { return "cislo_nonsubjektu"; } }
		/// <summary>
		/// Generátor SELECTU pro načítání do CACHE.
		/// Vrátí SQL SELECT, který používá SysCache pro automatické načítání záznamů do cache.
		/// Vrácený select má tvar "SELECT * FROM tabulka [join lcs.subjekty] WHERE [master_tabulka.]key_column", cache si doplní číslo[a] záznamů sama.
		/// </summary>
		/// <returns>Vrátí SQL SELECT, který používá SysCache pro automatické načítání záznamů do cache.</returns>
		public override string GetCacheSelect()
		{
			return SqlSelect + " WHERE " + SqlRecord;
		}
		#endregion
	}
	#endregion
	#region CLASS PlanUnitCClRelCls : Třída odvozená z tabulky lcs.plan_unit_c_cl_rel
	/// <summary>
	/// PlanUnitCClRelCls : Data z Master tabulky třídy 1367: Kap. úkoly a stav kap. vztahy (PlanUnitCClRelInst), Nonsubjektová
	/// Data načtena z tabulky lcs.plan_unit_c_cl_rel
	/// </summary>
	public partial class PlanUnitCClRelCls : RecordCls, Noris.Schedule.Support.Sql.IDbRecord
	{
		#region KONSTRUKTORY
		/// <summary>
		/// Implicitní konstruktor, zajistí číslování záznamů do jednotné Temporary řady
		/// </summary>
		public PlanUnitCClRelCls()
			: base()
		{ }
		/// <summary>
		/// Konstruktor s načítáním dat z databáze
		/// </summary>
		/// <param name="recordNumber">Číslo záznamu, který je třeba načíst</param>
		public PlanUnitCClRelCls(int recordNumber)
			: base(recordNumber)
		{ }
		/// <summary>
		/// Explicitní konstruktor, dovolí zvolit, zda se pro tento záznam bude generovat Temporary ID
		/// </summary>
		/// <param name="createTemporaryId">true pokud se pro záznam má vytvořit Temporary ID.
		/// Default (false) = nevytvoří se, bude mít RecordNumber = 0.</param>
		public PlanUnitCClRelCls(bool createTemporaryId)
			: base(createTemporaryId)
		{ }
		#endregion
		#region PUBLIC OVERRIDE PROPERTY
		/// <summary>Číslo třídy (1367)</summary>
		public override int ClassNumber { get { return ClassNr; } }
		/// <summary>Číslo třídy (1367)</summary>
		public const int ClassNr = 1367;
		/// <summary>Číslo záznamu = cislo_nonsubjektu</summary>
		public override int RecordNumber { get { return base._cislo_nonsubjektu; } }
		/// <summary>IDbRecord.RecordNumber : musí konkrétně implementovat set, protože DbLayer po uložení nového záznamu (kde RecordNumber == 0) do něj vloží přidělený klíč</summary>
		int IDbRecord.RecordNumber
		{
			get { return this.RecordNumber; }
			set { base._cislo_nonsubjektu = value; }
		}
		#endregion
		#region PUBLIC DATA PROPERTY
		///<summary><para>Atribut: Konec části úkolu v periodě [Datum_cas]</para><para>Db: lcs.plan_unit_c_cl_rel.end_task (datetime not null)</para></summary>
		public DateTime EndTask { get { return _end_task; } set { _end_task = value; } }
		///<summary><para>Atribut: Časový interval [editgeneral]</para><para>Db: lcs.plan_unit_c_cl_rel.interval (int not null)</para></summary>
		public int Interval { get { return _interval; } set { _interval = value; } }
		///<summary><para>Atribut: Množství [editnumeric_19_6]</para><para>Db: lcs.plan_unit_c_cl_rel.qty (numeric_19_6 not null)</para></summary>
		public decimal Qty { get { return _qty; } set { _qty = value; } }
		///<summary><para>Atribut: Počátek části úkolu v periodě</para><para>Db: lcs.plan_unit_c_cl_rel.start_task (datetime not null)</para></summary>
		public DateTime StartTask { get { return _start_task; } set { _start_task = value; } }
		///<summary><para>Vztah 100348: Stav kapacit (zprava: Kap. úkoly a stav kap. vztahy)</para><para>Db: lcs.plan_unit_c_cl_rel.plan_unit_c_cl (int not null)</para></summary>
		public int PlanUnitCCl { get { return _plan_unit_c_cl; } set { _plan_unit_c_cl = value; } }
		///<summary><para>Vztah 100349: Kapacitní úkol (zprava: Kap. úkoly a stav kap. vztahy)</para><para>Db: lcs.plan_unit_c_cl_rel.plan_unit_c_task (int not null)</para></summary>
		public int PlanUnitCTask { get { return _plan_unit_c_task; } set { _plan_unit_c_task = value; } }
		///<summary><para>Atribut: Registrace pro nadřazenou KPJ [typ_ano_ne] {"A"=Ano; "N"=Ne}</para><para>Db: lcs.plan_unit_c_cl_rel.reg_for_super (varchar (1) null)</para></summary>
		public string RegForSuper { get { return _reg_for_super; } set { _reg_for_super = value; } }
		///<summary><para>Vztah 102728: Kapacitní zdroj (zprava: Alokovaná kapacita)</para><para>Db: lcs.plan_unit_c_cl_rel.c_source (int null)</para></summary>
		public SqlInt32 CSource { get { return _c_source; } set { _c_source = value; } }
		#endregion
		#region PROTECTED DATA FIELDS
		protected DateTime _end_task;
		protected int _interval;
		protected decimal _qty;
		protected DateTime _start_task;
		protected int _plan_unit_c_cl;
		protected int _plan_unit_c_task;
		protected string _reg_for_super;
		protected SqlInt32 _c_source;
		#endregion
		#region FILL FROM READER
		/// <summary>
		/// Virtuální metoda, která umožňuje potomkům provádět typovou a rychlou konverzi dat proudících z databáze přes DataReader 
		/// přímo do objektu této třídy, bez použití generické metody FieldInfo.SetValue (která je poněkud pomalá).
		/// Tato metoda v této třídě tedy má naplnit každou svoji instanční proměnnou (field) hodnotou z předaného SqlDataReaderu.
		/// Pro snadné načtení dat je předán objekt mapper, který nabízí svou generickou metodu FillDataIntoField«int»(string dbColumnName, SqlDataReader reader).
		/// Tato metoda vrátí načtená data (typovaná jako objekt).
		/// Čtení touto metodou je cca 6x rychlejší než čtení generickou metodou.
		/// Metoda má vracet true, pokud převzala všechna data. 
		/// Je nanejvýše účelné, aby tak provedla, protože pokud vrátí false, pak se po jejím skončení provede generické ukládání dat (což je 6x pomalejší).
		/// </summary>
		/// <param name="reader">Vstupní DataReader</param>
		/// <param name="map">Mapování dat z readeru na fields tohoto objektu</param>
		/// <returns>true = data byla převzata / false = data nepřevzata</returns>
		public override bool FillFromReader(SqlDataReader reader, FieldMapperLoad map)
		{
			base.FillFromReader(reader, map);
			_end_task = (DateTime)map.FillDataIntoField<DateTime>("end_task", reader);
			_interval = (int)map.FillDataIntoField<int>("interval", reader);
			_qty = (decimal)map.FillDataIntoField<decimal>("qty", reader);
			_start_task = (DateTime)map.FillDataIntoField<DateTime>("start_task", reader);
			_plan_unit_c_cl = (int)map.FillDataIntoField<int>("plan_unit_c_cl", reader);
			_plan_unit_c_task = (int)map.FillDataIntoField<int>("plan_unit_c_task", reader);
			_reg_for_super = (string)map.FillDataIntoField<string>("reg_for_super", reader);
			_c_source = (SqlInt32)map.FillDataIntoField<SqlInt32>("c_source", reader);
			return true;
		}
		#endregion
		#region SAVE RECORD
		/// <summary>
		/// Zajistí přípravu svých dat do podkladové vrstvy pro uložení do databáze.
		/// Subjektové třídy musí nejprve volat SubjectCls.PrepareSaveData(this, map);, 
		/// tím se uloží data do tabulky subjektů (a pro nové záznamy se vygeneruje číslo subjektu).
		/// Nonsubjektové třídy to volat nesmí.
		/// </summary>
		/// <param name="map"></param>
		/// <returns></returns>
		public override bool PrepareSaveData(FieldMapperSave map)
		{
			map.AddTable("lcs.plan_unit_c_cl_rel", "cislo_nonsubjektu");
			map.AddColumn("end_task", this.EndTask);
			map.AddColumn("interval", this.Interval);
			map.AddColumn("qty", this.Qty);
			map.AddColumn("start_task", this.StartTask);
			map.AddColumn("plan_unit_c_cl", this.PlanUnitCCl);
			map.AddColumn("plan_unit_c_task", this.PlanUnitCTask);
			map.AddColumn("reg_for_super", this.RegForSuper);
			map.AddColumn("c_source", this.CSource);
			map.AddTableEnd();
			return true;
		}
		#endregion
		#region STATIC GENERÁTORY SELECTU
		/// <summary>
		/// SQL SELECT pro načtení columnů, odpovídajících této struktuře. Pozor: neobsahuje filtr ani order.
		/// </summary>
		public static new string SqlSelect { get { return @"SELECT * FROM lcs.plan_unit_c_cl_rel"; } }
		/// <summary>
		/// Jméno sloupce, který obsahuje klíč záznamu, určeno pro filtry.
		/// </summary>
		public static new string SqlRecord { get { return "cislo_nonsubjektu"; } }
		/// <summary>
		/// Generátor SELECTU pro načítání do CACHE.
		/// Vrátí SQL SELECT, který používá SysCache pro automatické načítání záznamů do cache.
		/// Vrácený select má tvar "SELECT * FROM tabulka [join lcs.subjekty] WHERE [master_tabulka.]key_column", cache si doplní číslo[a] záznamů sama.
		/// </summary>
		/// <returns>Vrátí SQL SELECT, který používá SysCache pro automatické načítání záznamů do cache.</returns>
		public override string GetCacheSelect()
		{
			return SqlSelect + " WHERE " + SqlRecord;
		}
		#endregion
	}
	#endregion
	#region CLASS PlanUnitCDeskCls : Třída odvozená z tabulky lcs.plan_unit_c_desk
	/// <summary>
	/// PlanUnitCDeskCls : Data z Master tabulky třídy 1818: Stav kapacit, kapacitní linka (PlanUnitCDeskInst), Nonsubjektová
	/// Data načtena z tabulky lcs.plan_unit_c_desk
	/// </summary>
	public partial class PlanUnitCDeskCls : RecordCls, Noris.Schedule.Support.Sql.IDbRecord
	{
		#region KONSTRUKTORY
		/// <summary>
		/// Implicitní konstruktor, zajistí číslování záznamů do jednotné Temporary řady
		/// </summary>
		public PlanUnitCDeskCls()
			: base()
		{ }
		/// <summary>
		/// Konstruktor s načítáním dat z databáze
		/// </summary>
		/// <param name="recordNumber">Číslo záznamu, který je třeba načíst</param>
		public PlanUnitCDeskCls(int recordNumber)
			: base(recordNumber)
		{ }
		/// <summary>
		/// Explicitní konstruktor, dovolí zvolit, zda se pro tento záznam bude generovat Temporary ID
		/// </summary>
		/// <param name="createTemporaryId">true pokud se pro záznam má vytvořit Temporary ID.
		/// Default (false) = nevytvoří se, bude mít RecordNumber = 0.</param>
		public PlanUnitCDeskCls(bool createTemporaryId)
			: base(createTemporaryId)
		{ }
		#endregion
		#region PUBLIC OVERRIDE PROPERTY
		/// <summary>Číslo třídy (1818)</summary>
		public override int ClassNumber { get { return ClassNr; } }
		/// <summary>Číslo třídy (1818)</summary>
		public const int ClassNr = 1818;
		/// <summary>Číslo záznamu = cislo_nonsubjektu</summary>
		public override int RecordNumber { get { return base._cislo_nonsubjektu; } }
		/// <summary>IDbRecord.RecordNumber : musí konkrétně implementovat set, protože DbLayer po uložení nového záznamu (kde RecordNumber == 0) do něj vloží přidělený klíč</summary>
		int IDbRecord.RecordNumber
		{
			get { return this.RecordNumber; }
			set { base._cislo_nonsubjektu = value; }
		}
		#endregion
		#region PUBLIC DATA PROPERTY
		///<summary><para>Atribut: Číslo linky</para><para>Db: lcs.plan_unit_c_desk.desk_index (smallint null)</para></summary>
		public SqlInt16 DeskIndex { get { return _desk_index; } set { _desk_index = value; } }
		///<summary><para>Atribut: Celková výchozí kapacita</para><para>Db: lcs.plan_unit_c_desk.capacity_total (numeric_19_6 null)</para></summary>
		public SqlDecimal CapacityTotal { get { return _capacity_total; } set { _capacity_total = value; } }
		///<summary><para>Atribut: Zůstatek disponibilní kapacity</para><para>Db: lcs.plan_unit_c_desk.capacity_disponible (numeric_19_6 null)</para></summary>
		public SqlDecimal CapacityDisponible { get { return _capacity_disponible; } set { _capacity_disponible = value; } }
		///<summary><para>Vztah 103307: Stav kapacit (zprava: Pracovní linka)</para><para>Db: lcs.plan_unit_c_desk.plan_unit_c_cl (int null)</para></summary>
		public SqlInt32 PlanUnitCCl { get { return _plan_unit_c_cl; } set { _plan_unit_c_cl = value; } }
		#endregion
		#region PROTECTED DATA FIELDS
		protected SqlInt16 _desk_index;
		protected SqlDecimal _capacity_total;
		protected SqlDecimal _capacity_disponible;
		protected SqlInt32 _plan_unit_c_cl;
		#endregion
		#region FILL FROM READER
		/// <summary>
		/// Virtuální metoda, která umožňuje potomkům provádět typovou a rychlou konverzi dat proudících z databáze přes DataReader 
		/// přímo do objektu této třídy, bez použití generické metody FieldInfo.SetValue (která je poněkud pomalá).
		/// Tato metoda v této třídě tedy má naplnit každou svoji instanční proměnnou (field) hodnotou z předaného SqlDataReaderu.
		/// Pro snadné načtení dat je předán objekt mapper, který nabízí svou generickou metodu FillDataIntoField«int»(string dbColumnName, SqlDataReader reader).
		/// Tato metoda vrátí načtená data (typovaná jako objekt).
		/// Čtení touto metodou je cca 6x rychlejší než čtení generickou metodou.
		/// Metoda má vracet true, pokud převzala všechna data. 
		/// Je nanejvýše účelné, aby tak provedla, protože pokud vrátí false, pak se po jejím skončení provede generické ukládání dat (což je 6x pomalejší).
		/// </summary>
		/// <param name="reader">Vstupní DataReader</param>
		/// <param name="map">Mapování dat z readeru na fields tohoto objektu</param>
		/// <returns>true = data byla převzata / false = data nepřevzata</returns>
		public override bool FillFromReader(SqlDataReader reader, FieldMapperLoad map)
		{
			base.FillFromReader(reader, map);
			_desk_index = (SqlInt16)map.FillDataIntoField<SqlInt16>("desk_index", reader);
			_capacity_total = (SqlDecimal)map.FillDataIntoField<SqlDecimal>("capacity_total", reader);
			_capacity_disponible = (SqlDecimal)map.FillDataIntoField<SqlDecimal>("capacity_disponible", reader);
			_plan_unit_c_cl = (SqlInt32)map.FillDataIntoField<SqlInt32>("plan_unit_c_cl", reader);
			return true;
		}
		#endregion
		#region SAVE RECORD
		/// <summary>
		/// Zajistí přípravu svých dat do podkladové vrstvy pro uložení do databáze.
		/// Subjektové třídy musí nejprve volat SubjectCls.PrepareSaveData(this, map);, 
		/// tím se uloží data do tabulky subjektů (a pro nové záznamy se vygeneruje číslo subjektu).
		/// Nonsubjektové třídy to volat nesmí.
		/// </summary>
		/// <param name="map"></param>
		/// <returns></returns>
		public override bool PrepareSaveData(FieldMapperSave map)
		{
			map.AddTable("lcs.plan_unit_c_desk", "cislo_nonsubjektu");
			map.AddColumn("desk_index", this.DeskIndex);
			map.AddColumn("capacity_total", this.CapacityTotal);
			map.AddColumn("capacity_disponible", this.CapacityDisponible);
			map.AddColumn("plan_unit_c_cl", this.PlanUnitCCl);
			map.AddTableEnd();
			return true;
		}
		#endregion
		#region STATIC GENERÁTORY SELECTU
		/// <summary>
		/// SQL SELECT pro načtení columnů, odpovídajících této struktuře. Pozor: neobsahuje filtr ani order.
		/// </summary>
		public static new string SqlSelect { get { return @"SELECT * FROM lcs.plan_unit_c_desk"; } }
		/// <summary>
		/// Jméno sloupce, který obsahuje klíč záznamu, určeno pro filtry.
		/// </summary>
		public static new string SqlRecord { get { return "cislo_nonsubjektu"; } }
		/// <summary>
		/// Generátor SELECTU pro načítání do CACHE.
		/// Vrátí SQL SELECT, který používá SysCache pro automatické načítání záznamů do cache.
		/// Vrácený select má tvar "SELECT * FROM tabulka [join lcs.subjekty] WHERE [master_tabulka.]key_column", cache si doplní číslo[a] záznamů sama.
		/// </summary>
		/// <returns>Vrátí SQL SELECT, který používá SysCache pro automatické načítání záznamů do cache.</returns>
		public override string GetCacheSelect()
		{
			return SqlSelect + " WHERE " + SqlRecord;
		}
		#endregion
	}
	#endregion
	#region CLASS PlanCSourceLinkCls : Třída odvozená z tabulky lcs.plan_c_source_link
	/// <summary>
	/// PlanCSourceLinkCls : Data z Master tabulky třídy 1592: Vztahy kap. jednotek a zdrojů (PlanCSourceLinkInst), Nonsubjektová
	/// Data načtena z tabulky lcs.plan_c_source_link
	/// </summary>
	public partial class PlanCSourceLinkCls : RecordCls, Noris.Schedule.Support.Sql.IDbRecord
	{
		#region KONSTRUKTORY
		/// <summary>
		/// Implicitní konstruktor, zajistí číslování záznamů do jednotné Temporary řady
		/// </summary>
		public PlanCSourceLinkCls()
			: base()
		{ }
		/// <summary>
		/// Konstruktor s načítáním dat z databáze
		/// </summary>
		/// <param name="recordNumber">Číslo záznamu, který je třeba načíst</param>
		public PlanCSourceLinkCls(int recordNumber)
			: base(recordNumber)
		{ }
		/// <summary>
		/// Explicitní konstruktor, dovolí zvolit, zda se pro tento záznam bude generovat Temporary ID
		/// </summary>
		/// <param name="createTemporaryId">true pokud se pro záznam má vytvořit Temporary ID.
		/// Default (false) = nevytvoří se, bude mít RecordNumber = 0.</param>
		public PlanCSourceLinkCls(bool createTemporaryId)
			: base(createTemporaryId)
		{ }
		#endregion
		#region PUBLIC OVERRIDE PROPERTY
		/// <summary>
		/// Číslo třídy: 1592
		/// </summary>
		public override int ClassNumber { get { return ClassNr; } }
		/// <summary>Číslo třídy</summary>
		public const int ClassNr = 1592;
		/// <summary>Číslo záznamu = cislo_nonsubjektu</summary>
		public override int RecordNumber { get { return base._cislo_nonsubjektu; } }
		/// <summary>IDbRecord.RecordNumber : musí konkrétně implementovat set, protože DbLayer po uložení nového záznamu (kde RecordNumber == 0) do něj vloží přidělený klíč</summary>
		int IDbRecord.RecordNumber
		{
			get { return this.RecordNumber; }
			set { base._cislo_nonsubjektu = value; }
		}
		#endregion
		#region PUBLIC DATA PROPERTY
		///<summary><para>Atribut: Priorita [mfr_unit]</para><para>Db: lcs.plan_c_source_link.priority (decimal (5) not null)</para></summary>
		public decimal Priority { get { return _priority; } }
		///<summary><para>Atribut: Procento plnění norem [mfr_unit]</para><para>Db: lcs.plan_c_source_link.befit_coef (decimal (5) not null)</para></summary>
		public decimal BefitCoef { get { return _befit_coef; } }
		///<summary><para>Vztah 101802: Kapacitní zdroj (zprava: Vztah na Kapacitní PJ)</para><para>Db: lcs.plan_c_source_link.c_source (int not null)</para></summary>
		public int CSource { get { return _c_source; } }
		///<summary><para>Vztah 101803: Kapacitní PJ (zprava: Vztah na Kapacitní zdroj)</para><para>Db: lcs.plan_c_source_link.plan_unit_c (int not null)</para></summary>
		public int PlanUnitC { get { return _plan_unit_c; } }
		///<summary><para>Atribut: Použít transportní čas [typ_ano_ne]</para><para>Db: lcs.plan_c_source_link.use_move_time (char (1) not null)</para></summary>
		public string UseMoveTime { get { return _use_move_time; } }
		///<summary><para>Atribut: Použít Tbc [typ_ano_ne]</para><para>Db: lcs.plan_c_source_link.use_tbc (char (1) not null)</para></summary>
		public string UseTbc { get { return _use_tbc; } }
		///<summary><para>Atribut: Použít Tac [typ_ano_ne]</para><para>Db: lcs.plan_c_source_link.use_tac (char (1) not null)</para></summary>
		public string UseTac { get { return _use_tac; } }
		///<summary><para>Atribut: Použít Tec [typ_ano_ne]</para><para>Db: lcs.plan_c_source_link.use_tec (char (1) not null)</para></summary>
		public string UseTec { get { return _use_tec; } }
		#endregion
		#region PROTECTED DATA FIELDS
		protected decimal _priority;
		protected decimal _befit_coef;
		protected int _c_source;
		protected int _plan_unit_c;
		protected string _use_move_time;
		protected string _use_tbc;
		protected string _use_tac;
		protected string _use_tec;
		#endregion
		#region FILL FROM READER
		/// <summary>
		/// Virtuální metoda, která umožňuje potomkům provádět typovou a rychlou konverzi dat proudících z databáze přes DataReader 
		/// přímo do objektu této třídy, bez použití generické metody FieldInfo.SetValue (která je poněkud pomalá).
		/// Tato metoda v této třídě tedy má naplnit každou svoji instanční proměnnou (field) hodnotou z předaného SqlDataReaderu.
		/// Pro snadné načtení dat je předán objekt mapper, který nabízí svou generickou metodu FillDataIntoField«int»(string dbColumnName, SqlDataReader reader).
		/// Tato metoda vrátí načtená data (typovaná jako objekt).
		/// Čtení touto metodou je cca 6x rychlejší než čtení generickou metodou.
		/// Metoda má vracet true, pokud převzala všechna data. 
		/// Je nanejvýše účelné, aby tak provedla, protože pokud vrátí false, pak se po jejím skončení provede generické ukládání dat (což je 6x pomalejší).
		/// </summary>
		/// <param name="reader">Vstupní DataReader</param>
		/// <param name="map">Mapování dat z readeru na fields tohoto objektu</param>
		/// <returns>true = data byla převzata / false = data nepřevzata</returns>
		public override bool FillFromReader(SqlDataReader reader, FieldMapperLoad map)
		{
			base.FillFromReader(reader, map);
			_priority = (decimal)map.FillDataIntoField<decimal>("priority", reader);
			_befit_coef = (decimal)map.FillDataIntoField<decimal>("befit_coef", reader);
			_c_source = (int)map.FillDataIntoField<int>("c_source", reader);
			_plan_unit_c = (int)map.FillDataIntoField<int>("plan_unit_c", reader);
			_use_move_time = (string)map.FillDataIntoField<string>("use_move_time", reader);
			_use_tbc = (string)map.FillDataIntoField<string>("use_tbc", reader);
			_use_tac = (string)map.FillDataIntoField<string>("use_tac", reader);
			_use_tec = (string)map.FillDataIntoField<string>("use_tec", reader);
			return true;
		}
		#endregion
		#region STATIC GENERÁTORY SELECTU
		/// <summary>
		/// SQL SELECT pro načtení columnů, odpovídajících této struktuře. Pozor: neobsahuje filtr ani order.
		/// </summary>
		public static new string SqlSelect { get { return "SELECT * FROM lcs.plan_c_source_link"; } }
		/// <summary>
		/// Jméno sloupce, který obsahuje klíč záznamu, určeno pro filtry.
		/// </summary>
		public static new string SqlRecord { get { return "cislo_nonsubjektu"; } }
		/// <summary>
		/// Generátor SELECTU pro načítání do CACHE.
		/// Vrátí SQL SELECT, který používá SysCache pro automatické načítání záznamů do cache.
		/// Vrácený select má tvar "SELECT * FROM tabulka [join lcs.subjekty] WHERE [master_tabulka.]key_column", cache si doplní číslo[a] záznamů sama.
		/// </summary>
		/// <returns>Vrátí SQL SELECT, který používá SysCache pro automatické načítání záznamů do cache.</returns>
		public override string GetCacheSelect()
		{
			return SqlSelect + " WHERE " + SqlRecord;
		}
		#endregion
	}
	#endregion
    #region CLASS PlanCVersionHdrCls : Třída odvozená z tabulky lcs.plan_c_version_hdr
    /// <summary>
    /// PlanCVersionHdrCls : Data z Master tabulky třídy 1362: Kapacitní plán verze (PlanCVersionInst), Subjektová
    /// Data načtena z tabulky lcs.plan_c_version_hdr
    /// </summary>
    public partial class PlanCVersionHdrCls : RecordCls, Noris.Schedule.Support.Sql.IDbRecord
    {
        #region KONSTRUKTORY
        /// <summary>
        /// Implicitní konstruktor, zajistí číslování záznamů do jednotné Temporary řady
        /// </summary>
        public PlanCVersionHdrCls()
            : base()
        { }
        /// <summary>
        /// Konstruktor s načítáním dat z databáze
        /// </summary>
        /// <param name="recordNumber">Číslo záznamu, který je třeba načíst</param>
        public PlanCVersionHdrCls(int recordNumber)
            : base(recordNumber)
        { }
        /// <summary>
        /// Explicitní konstruktor, dovolí zvolit, zda se pro tento záznam bude generovat Temporary ID
        /// </summary>
        /// <param name="createTemporaryId">true pokud se pro záznam má vytvořit Temporary ID.
        /// Default (false) = nevytvoří se, bude mít RecordNumber = 0.</param>
        public PlanCVersionHdrCls(bool createTemporaryId)
            : base(createTemporaryId)
        { }
        #endregion
        #region PUBLIC OVERRIDE PROPERTY
        /// <summary>Číslo třídy (1362)</summary>
        public override int ClassNumber { get { return ClassNr; } }
        /// <summary>Číslo třídy (1362)</summary>
        public const int ClassNr = 1362;
        /// <summary>Číslo záznamu = cislo_subjektu</summary>
        public override int RecordNumber { get { return base._cislo_subjektu; } }
        /// <summary>IDbRecord.RecordNumber : musí konkrétně implementovat set, protože DbLayer po uložení nového záznamu (kde RecordNumber == 0) do něj vloží přidělený klíč</summary>
        int IDbRecord.RecordNumber
        {
            get { return this.RecordNumber; }
            set { base._cislo_subjektu = value; }
        }
        #endregion
        #region PUBLIC DATA PROPERTY
        ///<summary><para>Atribut: Text</para><para>Db: lcs.plan_c_version_hdr.version_description (varchar (255) null)</para></summary>
        public string VersionDescription { get { return _version_description; } }
        ///<summary><para>Atribut: Mazat plán [typ_ano_ne] {"A"=Ano; "N"=Ne}</para><para>Db: lcs.plan_c_version_hdr.delete_plan (char (1) not null)</para></summary>
        public string DeletePlan { get { return _delete_plan; } }
        ///<summary><para>Vztah 100518: Plánované útvary (zprava: Verze kap.planu)</para><para>Db: lcs.plan_c_version_hdr.puc_filter (int null)</para></summary>
        public SqlInt32 PucFilter { get { return _puc_filter; } }
        ///<summary><para>Atribut: Datum počátku plánování [Datum_cas]</para><para>Db: lcs.plan_c_version_hdr.date_start (datetime not null)</para></summary>
        public DateTime DateStart { get { return _date_start; } }
        ///<summary><para>Atribut: Kumulační perioda [editgeneral]</para><para>Db: lcs.plan_c_version_hdr.mrp_aggr_period (int null)</para></summary>
        public SqlInt32 MrpAggrPeriod { get { return _mrp_aggr_period; } }
        ///<summary><para>Atribut: Rozšířený log procesu [typ_ano_ne] {"A"=Ano; "N"=Ne}</para><para>Db: lcs.plan_c_version_hdr.mrp_extended_log (char (1) null)</para></summary>
        public string MrpExtendedLog { get { return _mrp_extended_log; } }
        ///<summary><para>Atribut: Uvažovat pevné ztráty na dílci</para><para>Db: lcs.plan_c_version_hdr.mrp_fixed_loss_ce_reflect (char (1) null)</para></summary>
        public string MrpFixedLossCeReflect { get { return _mrp_fixed_loss_ce_reflect; } }
        ///<summary><para>Atribut: Uvažovat skladovou zásobu [typ_ano_ne] {"A"=Ano; "N"=Ne}</para><para>Db: lcs.plan_c_version_hdr.mrp_fund_reflect (char (1) null)</para></summary>
        public string MrpFundReflect { get { return _mrp_fund_reflect; } }
        ///<summary><para>Atribut: Z Poptávek, Objednávek a Potvrz. Obj. [typ_ano_ne] {"A"=Ano; "N"=Ne}</para><para>Db: lcs.plan_c_version_hdr.mrp_init_enquire_reflect (char (1) null)</para></summary>
        public string MrpInitEnquireReflect { get { return _mrp_init_enquire_reflect; } }
        ///<summary><para>Atribut: Z nerealizovaných poptávek plánu [typ_ano_ne] {"A"=Ano; "N"=Ne}</para><para>Db: lcs.plan_c_version_hdr.mrp_init_plan_enquire_reflect (char (1) null)</para></summary>
        public string MrpInitPlanEnquireReflect { get { return _mrp_init_plan_enquire_reflect; } }
        ///<summary><para>Atribut: Z neodvedených zůstatků sestav VP [typ_ano_ne] {"A"=Ano; "N"=Ne}</para><para>Db: lcs.plan_c_version_hdr.mrp_init_po_reflect (char (1) null)</para></summary>
        public string MrpInitPoReflect { get { return _mrp_init_po_reflect; } }
        ///<summary><para>Atribut: Z předpokl. výdejů do kusovníků VP [typ_ano_ne] {"A"=Ano; "N"=Ne}</para><para>Db: lcs.plan_c_version_hdr.mrp_init_po_structure_reflect (char (1) null)</para></summary>
        public string MrpInitPoStructureReflect { get { return _mrp_init_po_structure_reflect; } }
        ///<summary><para>Atribut: KKZM Plánovat použít i pro komponenty [typ_ano_ne] {"A"=Ano; "N"=Ne}</para><para>Db: lcs.plan_c_version_hdr.mrp_kkzmplan_accept (char (1) null)</para></summary>
        public string MrpKkzmplanAccept { get { return _mrp_kkzmplan_accept; } }
        ///<summary><para>Atribut: Uvažovat min. množství skladu [mfr_mrp_minstock_mode] {"N"=Neuvažovat; "A"=Zajistit min. množství k datu prvního návrhu; "C"=Zajistit min. množství po celou dobu plánu}</para><para>Db: lcs.plan_c_version_hdr.mrp_minimum_stock_reflect (char (1) null)</para></summary>
        public string MrpMinimumStockReflect { get { return _mrp_minimum_stock_reflect; } }
        ///<summary><para>Atribut: Posun návrhu na zaj. MM v MRP</para><para>Db: lcs.plan_c_version_hdr.mrp_minqty_days (int null)</para></summary>
        public SqlInt32 MrpMinqtyDays { get { return _mrp_minqty_days; } }
        ///<summary><para>Atribut: Uvažovat % ztráty na dílci [typ_ano_ne] {"A"=Ano; "N"=Ne}</para><para>Db: lcs.plan_c_version_hdr.mrp_percent_loss_ce_reflect (char (1) null)</para></summary>
        public string MrpPercentLossCeReflect { get { return _mrp_percent_loss_ce_reflect; } }
        ///<summary><para>Atribut: Datum plán uvažovat [mfr_plan_date_round_type] {"D"=Minimální; "U"=Maximální; "E"=Zadané v plánu}</para><para>Db: lcs.plan_c_version_hdr.mrp_plan_date_round_type (char (1) null)</para></summary>
        public string MrpPlanDateRoundType { get { return _mrp_plan_date_round_type; } }
        ///<summary><para>Atribut: Přebírat do MRP nepár. plán [mrp_plan_nolink] {"n"=Nevyužívat párovací funkce Plán - Realita; "p"=Použít existující výsledky funkce Plán - Realita; "r"=Spustit funkci Plán - Realita a použít výsledky}</para><para>Db: lcs.plan_c_version_hdr.mrp_plan_nolink (char (1) null)</para></summary>
        public string MrpPlanNolink { get { return _mrp_plan_nolink; } }
        ///<summary><para>Atribut: Uvažovat dělitele množství [typ_ano_ne] {"A"=Ano; "N"=Ne}</para><para>Db: lcs.plan_c_version_hdr.mrp_qty_divider_reflect (char (1) null)</para></summary>
        public string MrpQtyDividerReflect { get { return _mrp_qty_divider_reflect; } }
        ///<summary><para>Atribut: Max opoždění zajištění</para><para>Db: lcs.plan_c_version_hdr.mrp_req_delay_ordr (int null)</para></summary>
        public SqlInt32 MrpReqDelayOrdr { get { return _mrp_req_delay_ordr; } }
        ///<summary>
        ///<para>Atribut: Způsob termínování [mfr_timing_type] {"S"=Dle stavu skladu; "T"=Dle průběžných dob; "F"=Dle dostupných kapacit}</para>
        ///<para>Db: lcs.plan_c_version_hdr.mrp_timing_type (char (1) null)</para>
        ///</summary>
        public string MrpTimingType { get { return _mrp_timing_type; } }
        ///<summary><para>Atribut: Pracovat s kategoriemi [typ_ano_ne] {"A"=Ano; "N"=Ne}</para><para>Db: lcs.plan_c_version_hdr.mrp_work_with_categories (char (1) null)</para></summary>
        public string MrpWorkWithCategories { get { return _mrp_work_with_categories; } }
        ///<summary><para>Atribut: Výběr T modifikací pro MRP [mfr_vyber_t_mod] {1=1: podle plánovaného termínu zahájení; 2=2: podle plánovaného termínu zahájení, a je-li menší než dnes, tak dnes; 3=3: dnešní datum (datum spuštění funkce); 4=4: nejvyšší datum z platných modifikací; 5=5: nejnižší datum z platných modifikací (může jít i do minulosti)}</para><para>Db: lcs.plan_c_version_hdr.sel_mrp_mod (int null)</para></summary>
        public SqlInt32 SelMrpMod { get { return _sel_mrp_mod; } }
        ///<summary><para>Atribut: Min.dod. i pro návrh Min.zásoba [typ_ano_ne] {"A"=Ano; "N"=Ne}</para><para>Db: lcs.plan_c_version_hdr.mrp_mindod_to_minlevel (char (1) null)</para></summary>
        public string MrpMindodToMinlevel { get { return _mrp_mindod_to_minlevel; } }
        ///<summary><para>Atribut: Termínování komponent [mfr_mrp_structure_timing] {1=Na začátek operace; 2=Na začátek času TAC; 3=Na začátek konkrétní výrobní dávky}</para><para>Db: lcs.plan_c_version_hdr.mrp_structure_timing (smallint null)</para></summary>
        public SqlInt16 MrpStructureTiming { get { return _mrp_structure_timing; } }
        ///<summary><para>Atribut: Typ omezení kapacit [mfr_process_c_type] {"U"=Neomezené kapacity; "L"=Omezené kapacity; "P"=Dle konkrétní kapacitní jednotky}</para><para>Db: lcs.plan_c_version_hdr.cpl_puc_limited (char (1) null)</para></summary>
        public string CplPucLimited { get { return _cpl_puc_limited; } }
        ///<summary><para>Atribut: Termínování mezioper.času [mfr_movetime_term] {"R"=Prostý čas; "K"=Jeden konkrétní kalendář; "P"=Kalendář podle pracoviště operace; "C"=Registrovat do kapacit pracoviště}</para><para>Db: lcs.plan_c_version_hdr.cpl_move_time_type (char (1) null)</para></summary>
        public string CplMoveTimeType { get { return _cpl_move_time_type; } }
        ///<summary><para>Atribut: Termínování času bez KPJ [mfr_movetime_term] {"R"=Prostý čas; "K"=Jeden konkrétní kalendář; "P"=Kalendář podle pracoviště operace; "C"=Registrovat do kapacit pracoviště}</para><para>Db: lcs.plan_c_version_hdr.cpl_none_time_type (char (1) null)</para></summary>
        public string CplNoneTimeType { get { return _cpl_none_time_type; } }
        ///<summary><para>Atribut: Používat dělení na výrobní dávky [typ_ano_ne] {"A"=Ano; "N"=Ne}</para><para>Db: lcs.plan_c_version_hdr.use_move_batch_qty (char (1) null)</para></summary>
        public string UseMoveBatchQty { get { return _use_move_batch_qty; } }
        ///<summary><para>Atribut: Výrobní dávky i na další dílec [typ_ano_ne] {"A"=Ano; "N"=Ne}</para><para>Db: lcs.plan_c_version_hdr.use_move_batch_transfer (char (1) null)</para></summary>
        public string UseMoveBatchTransfer { get { return _use_move_batch_transfer; } }
        ///<summary><para>Atribut: Plánování kapacit pro profese [mfr_cplplan_unit_mode] {0=Neplánovat; 1=Plánovat nejvhodnější, střídat podle potřeby; 2=Plánovat nejvhodnější, pokud možno nestřídat; 3=Plánovat nejvhodnější, nestřídat, čekat na uvolnění původní; 4=Plánovat nejvhodnější, nestřídat jednotky nikdy}</para><para>Db: lcs.plan_c_version_hdr.cpl_plan_profession (smallint null)</para></summary>
        public SqlInt16 CplPlanProfession { get { return _cpl_plan_profession; } }
        ///<summary><para>Atribut: Plánování kapacit pro zdroje operací [mfr_cplplan_unit_mode] {0=Neplánovat; 1=Plánovat nejvhodnější, střídat podle potřeby; 2=Plánovat nejvhodnější, pokud možno nestřídat; 3=Plánovat nejvhodnější, nestřídat, čekat na uvolnění původní; 4=Plánovat nejvhodnější, nestřídat jednotky nikdy}</para><para>Db: lcs.plan_c_version_hdr.cpl_plan_resource (smallint null)</para></summary>
        public SqlInt16 CplPlanResource { get { return _cpl_plan_resource; } }
        ///<summary><para>Atribut: Plánování kapacit pro pracoviště [mfr_cplplan_unit_mode] {0=Neplánovat; 1=Plánovat nejvhodnější, střídat podle potřeby; 2=Plánovat nejvhodnější, pokud možno nestřídat; 3=Plánovat nejvhodnější, nestřídat, čekat na uvolnění původní; 4=Plánovat nejvhodnější, nestřídat jednotky nikdy}</para><para>Db: lcs.plan_c_version_hdr.cpl_plan_workplace (smallint null)</para></summary>
        public SqlInt16 CplPlanWorkplace { get { return _cpl_plan_workplace; } }
        ///<summary><para>Vztah 104452: Filtr položky reálné poptávky (zprava: Kapacitní plán verze)</para><para>Db: lcs.plan_c_version_hdr.mrp_realpopt_filter (int null)</para></summary>
        public SqlInt32 MrpRealpoptFilter { get { return _mrp_realpopt_filter; } }
        ///<summary><para>Vztah 104453: Párovací znak popt-obj (zprava: Konfigurace modulu výroba)</para><para>Db: lcs.plan_c_version_hdr.mrp_planreal_expr (int null)</para></summary>
        public SqlInt32 MrpPlanrealExpr { get { return _mrp_planreal_expr; } }
        ///<summary><para>Vztah 104454: Filtr položky neponižující plán (zprava: Konfigurace modulu výroba)</para><para>Db: lcs.plan_c_version_hdr.mrp_plan_omit_filter (int null)</para></summary>
        public SqlInt32 MrpPlanOmitFilter { get { return _mrp_plan_omit_filter; } }
        ///<summary><para>Vztah 104455: Filtr položky poptávky plánu (zprava: Konfigurace modulu výroba)</para><para>Db: lcs.plan_c_version_hdr.mrp_plan_filter (int null)</para></summary>
        public SqlInt32 MrpPlanFilter { get { return _mrp_plan_filter; } }
        ///<summary><para>Vztah 104481: Filtr položky objednávky (zprava: Kapacitní plán verze)</para><para>Db: lcs.plan_c_version_hdr.mrp_objedn_filter (int null)</para></summary>
        public SqlInt32 MrpObjednFilter { get { return _mrp_objedn_filter; } }
        ///<summary><para>Vztah 104482: Kalendář mezioperačního času (zprava: Verze kapacitního plánu)</para><para>Db: lcs.plan_c_version_hdr.cpl_move_time_calend (int null)</para></summary>
        public SqlInt32 CplMoveTimeCalend { get { return _cpl_move_time_calend; } }
        ///<summary><para>Vztah 104484: Kalendář času bez KPJ (zprava: Verze kapacitního plánu)</para><para>Db: lcs.plan_c_version_hdr.cpl_none_time_calend (int null)</para></summary>
        public SqlInt32 CplNoneTimeCalend { get { return _cpl_none_time_calend; } }
        ///<summary><para>Vztah 104585: Filtr objednávky do výroby (zprava: Kapacitní plán verze)</para><para>Db: lcs.plan_c_version_hdr.mrp_objedn_vyr_filter (int null)</para></summary>
        public SqlInt32 MrpObjednVyrFilter { get { return _mrp_objedn_vyr_filter; } }
        ///<summary><para>Atribut: Varianta plánovacího procesu [mfr_planning_variation] {100=MRP zpětně, KPL dopředně; 101=MRP zpětně, KPL zpětně}</para><para>Db: lcs.plan_c_version_hdr.planning_variation (int null)</para></summary>
        public SqlInt32 PlanningVariation { get { return _planning_variation; } }
        ///<summary><para>Atribut: Stav procesu plánování [mfr_planning_state] {1=Neexistuje; 2=Plán je otevřený; 3=Upravuje se; 4=Ukládání dat; 5=Uložen a otevřen; 6=Uložený}</para><para>Db: lcs.plan_c_version_hdr.planning_state (int null)</para></summary>
        public SqlInt32 PlanningState { get { return _planning_state; } }
        ///<summary><para>Vztah 105785: Kdo zpracovává plán (zprava: Pracuje na výrobním plánu)</para><para>Db: lcs.plan_c_version_hdr.working_user (int null)</para></summary>
        public SqlInt32 WorkingUser { get { return _working_user; } }
        ///<summary><para>Atribut: Poslední aktivita plánování</para><para>Db: lcs.plan_c_version_hdr.working_time (datetime null)</para></summary>
        public SqlDateTime WorkingTime { get { return _working_time; } }
        ///<summary><para>Vztah 105786: Kdo uložil plán (zprava: Uložil výrobní plán)</para><para>Db: lcs.plan_c_version_hdr.last_plan_user (int null)</para></summary>
        public SqlInt32 LastPlanUser { get { return _last_plan_user; } }
        ///<summary><para>Atribut: Poslední čas uložení plánu</para><para>Db: lcs.plan_c_version_hdr.last_plan_time (datetime null)</para></summary>
        public SqlDateTime LastPlanTime { get { return _last_plan_time; } }
        #endregion
        #region PROTECTED DATA FIELDS
#pragma warning disable 1591
        protected string _version_description;
        protected string _delete_plan;
        protected SqlInt32 _puc_filter;
        protected DateTime _date_start;
        protected SqlInt32 _mrp_aggr_period;
        protected string _mrp_extended_log;
        protected string _mrp_fixed_loss_ce_reflect;
        protected string _mrp_fund_reflect;
        protected string _mrp_init_enquire_reflect;
        protected string _mrp_init_plan_enquire_reflect;
        protected string _mrp_init_po_reflect;
        protected string _mrp_init_po_structure_reflect;
        protected string _mrp_kkzmplan_accept;
        protected string _mrp_minimum_stock_reflect;
        protected SqlInt32 _mrp_minqty_days;
        protected string _mrp_percent_loss_ce_reflect;
        protected string _mrp_plan_date_round_type;
        protected string _mrp_plan_nolink;
        protected string _mrp_qty_divider_reflect;
        protected SqlInt32 _mrp_req_delay_ordr;
        protected string _mrp_timing_type;
        protected string _mrp_work_with_categories;
        protected SqlInt32 _sel_mrp_mod;
        protected string _mrp_mindod_to_minlevel;
        protected SqlInt16 _mrp_structure_timing;
        protected string _cpl_puc_limited;
        protected string _cpl_move_time_type;
        protected string _cpl_none_time_type;
        protected string _use_move_batch_qty;
        protected string _use_move_batch_transfer;
        protected SqlInt16 _cpl_plan_profession;
        protected SqlInt16 _cpl_plan_resource;
        protected SqlInt16 _cpl_plan_workplace;
        protected SqlInt32 _mrp_realpopt_filter;
        protected SqlInt32 _mrp_planreal_expr;
        protected SqlInt32 _mrp_plan_omit_filter;
        protected SqlInt32 _mrp_plan_filter;
        protected SqlInt32 _mrp_objedn_filter;
        protected SqlInt32 _cpl_move_time_calend;
        protected SqlInt32 _cpl_none_time_calend;
        protected SqlInt32 _mrp_objedn_vyr_filter;
        protected SqlInt32 _planning_variation;
        protected SqlInt32 _planning_state;
        protected SqlInt32 _working_user;
        protected SqlDateTime _working_time;
        protected SqlInt32 _last_plan_user;
        protected SqlDateTime _last_plan_time;
#pragma warning restore 1591
        #endregion
        #region FILL FROM READER
        /// <summary>
        /// Virtuální metoda, která umožňuje potomkům provádět typovou a rychlou konverzi dat proudících z databáze přes DataReader 
        /// přímo do objektu této třídy, bez použití generické metody FieldInfo.SetValue (která je poněkud pomalá).
        /// Tato metoda v této třídě tedy má naplnit každou svoji instanční proměnnou (field) hodnotou z předaného SqlDataReaderu.
        /// Pro snadné načtení dat je předán objekt mapper, který nabízí svou generickou metodu FillDataIntoField«int»(string dbColumnName, SqlDataReader reader).
        /// Tato metoda vrátí načtená data (typovaná jako objekt).
        /// Čtení touto metodou je cca 6x rychlejší než čtení generickou metodou.
        /// Metoda má vracet true, pokud převzala všechna data. 
        /// Je nanejvýše účelné, aby tak provedla, protože pokud vrátí false, pak se po jejím skončení provede generické ukládání dat (což je 6x pomalejší).
        /// </summary>
        /// <param name="reader">Vstupní DataReader</param>
        /// <param name="map">Mapování dat z readeru na fields tohoto objektu</param>
        /// <returns>true = data byla převzata / false = data nepřevzata</returns>
        public override bool FillFromReader(SqlDataReader reader, FieldMapperLoad map)
        {
            base.FillFromReader(reader, map);
            _version_description = (string)map.FillDataIntoField<string>("version_description", reader);
            _delete_plan = (string)map.FillDataIntoField<string>("delete_plan", reader);
            _puc_filter = (SqlInt32)map.FillDataIntoField<SqlInt32>("puc_filter", reader);
            _date_start = (DateTime)map.FillDataIntoField<DateTime>("date_start", reader);
            _mrp_aggr_period = (SqlInt32)map.FillDataIntoField<SqlInt32>("mrp_aggr_period", reader);
            _mrp_extended_log = (string)map.FillDataIntoField<string>("mrp_extended_log", reader);
            _mrp_fixed_loss_ce_reflect = (string)map.FillDataIntoField<string>("mrp_fixed_loss_ce_reflect", reader);
            _mrp_fund_reflect = (string)map.FillDataIntoField<string>("mrp_fund_reflect", reader);
            _mrp_init_enquire_reflect = (string)map.FillDataIntoField<string>("mrp_init_enquire_reflect", reader);
            _mrp_init_plan_enquire_reflect = (string)map.FillDataIntoField<string>("mrp_init_plan_enquire_reflect", reader);
            _mrp_init_po_reflect = (string)map.FillDataIntoField<string>("mrp_init_po_reflect", reader);
            _mrp_init_po_structure_reflect = (string)map.FillDataIntoField<string>("mrp_init_po_structure_reflect", reader);
            _mrp_kkzmplan_accept = (string)map.FillDataIntoField<string>("mrp_kkzmplan_accept", reader);
            _mrp_minimum_stock_reflect = (string)map.FillDataIntoField<string>("mrp_minimum_stock_reflect", reader);
            _mrp_minqty_days = (SqlInt32)map.FillDataIntoField<SqlInt32>("mrp_minqty_days", reader);
            _mrp_percent_loss_ce_reflect = (string)map.FillDataIntoField<string>("mrp_percent_loss_ce_reflect", reader);
            _mrp_plan_date_round_type = (string)map.FillDataIntoField<string>("mrp_plan_date_round_type", reader);
            _mrp_plan_nolink = (string)map.FillDataIntoField<string>("mrp_plan_nolink", reader);
            _mrp_qty_divider_reflect = (string)map.FillDataIntoField<string>("mrp_qty_divider_reflect", reader);
            _mrp_req_delay_ordr = (SqlInt32)map.FillDataIntoField<SqlInt32>("mrp_req_delay_ordr", reader);
            _mrp_timing_type = (string)map.FillDataIntoField<string>("mrp_timing_type", reader);
            _mrp_work_with_categories = (string)map.FillDataIntoField<string>("mrp_work_with_categories", reader);
            _sel_mrp_mod = (SqlInt32)map.FillDataIntoField<SqlInt32>("sel_mrp_mod", reader);
            _mrp_mindod_to_minlevel = (string)map.FillDataIntoField<string>("mrp_mindod_to_minlevel", reader);
            _mrp_structure_timing = (SqlInt16)map.FillDataIntoField<SqlInt16>("mrp_structure_timing", reader);
            _cpl_puc_limited = (string)map.FillDataIntoField<string>("cpl_puc_limited", reader);
            _cpl_move_time_type = (string)map.FillDataIntoField<string>("cpl_move_time_type", reader);
            _cpl_none_time_type = (string)map.FillDataIntoField<string>("cpl_none_time_type", reader);
            _use_move_batch_qty = (string)map.FillDataIntoField<string>("use_move_batch_qty", reader);
            _use_move_batch_transfer = (string)map.FillDataIntoField<string>("use_move_batch_transfer", reader);
            _cpl_plan_profession = (SqlInt16)map.FillDataIntoField<SqlInt16>("cpl_plan_profession", reader);
            _cpl_plan_resource = (SqlInt16)map.FillDataIntoField<SqlInt16>("cpl_plan_resource", reader);
            _cpl_plan_workplace = (SqlInt16)map.FillDataIntoField<SqlInt16>("cpl_plan_workplace", reader);
            _mrp_realpopt_filter = (SqlInt32)map.FillDataIntoField<SqlInt32>("mrp_realpopt_filter", reader);
            _mrp_planreal_expr = (SqlInt32)map.FillDataIntoField<SqlInt32>("mrp_planreal_expr", reader);
            _mrp_plan_omit_filter = (SqlInt32)map.FillDataIntoField<SqlInt32>("mrp_plan_omit_filter", reader);
            _mrp_plan_filter = (SqlInt32)map.FillDataIntoField<SqlInt32>("mrp_plan_filter", reader);
            _mrp_objedn_filter = (SqlInt32)map.FillDataIntoField<SqlInt32>("mrp_objedn_filter", reader);
            _cpl_move_time_calend = (SqlInt32)map.FillDataIntoField<SqlInt32>("cpl_move_time_calend", reader);
            _cpl_none_time_calend = (SqlInt32)map.FillDataIntoField<SqlInt32>("cpl_none_time_calend", reader);
            _mrp_objedn_vyr_filter = (SqlInt32)map.FillDataIntoField<SqlInt32>("mrp_objedn_vyr_filter", reader);
            _planning_variation = (SqlInt32)map.FillDataIntoField<SqlInt32>("planning_variation", reader);
            _planning_state = (SqlInt32)map.FillDataIntoField<SqlInt32>("planning_state", reader);
            _working_user = (SqlInt32)map.FillDataIntoField<SqlInt32>("working_user", reader);
            _working_time = (SqlDateTime)map.FillDataIntoField<SqlDateTime>("working_time", reader);
            _last_plan_user = (SqlInt32)map.FillDataIntoField<SqlInt32>("last_plan_user", reader);
            _last_plan_time = (SqlDateTime)map.FillDataIntoField<SqlDateTime>("last_plan_time", reader);
            return true;
        }
        #endregion
        #region SAVE RECORD (VOID)
        /// <summary>
        /// Zajistí přípravu svých dat do podkladové vrstvy pro uložení do databáze.
        /// Subjektové třídy musí nejprve volat SubjectCls.PrepareSaveData(this, map);, 
        /// tím se uloží data do tabulky subjektů (a pro nové záznamy se vygeneruje číslo subjektu).
        /// Nonsubjektové třídy to volat nesmí.
        /// </summary>
        /// <param name="map"></param>
        /// <returns></returns>
        public override bool PrepareSaveData(FieldMapperSave map)
        {
            return false;
        }
        #endregion
        #region STATIC GENERÁTORY SELECTU
        /// <summary>
        /// SQL SELECT pro načtení columnů, odpovídajících této struktuře. Pozor: neobsahuje filtr ani order.
        /// </summary>
        public static new string SqlSelect { get { return @"SELECT * FROM lcs.plan_c_version_hdr"; } }
        /// <summary>
        /// Jméno sloupce, který obsahuje klíč záznamu, určeno pro filtry.
        /// </summary>
        public static new string SqlRecord { get { return "cislo_subjektu"; } }
        /// <summary>
        /// Generátor SELECTU pro načítání do CACHE.
        /// Vrátí SQL SELECT, který používá SysCache pro automatické načítání záznamů do cache.
        /// Vrácený select má tvar "SELECT * FROM tabulka [join lcs.subjekty] WHERE [master_tabulka.]key_column", cache si doplní číslo[a] záznamů sama.
        /// </summary>
        /// <returns>Vrátí SQL SELECT, který používá SysCache pro automatické načítání záznamů do cache.</returns>
        public override string GetCacheSelect()
        {
            return SqlSelect + " WHERE " + SqlRecord;
        }
        #endregion
    }
    #endregion
}
